const express = require('express');
const router = express.Router();

// 数据库配置文件
const db  = require('../Mysql/index')
const bcrypt = require('bcrypt');
// 密码加密
const jm = require('bcryptjs')
let sql;

const moment = require('moment');
// 查询一二级路由分类列表
router.get('/Admin/RoutePage_List', (req, res) => {
    const data = req.query;
    // 查询所有一级路由分类
    const routesSql = `SELECT *,id as value,name as label FROM route_class`;
    // 查询所有二级路由
    const routeSql = `SELECT *,id as value,name as label FROM route
        WHERE is_show = 1`;
    db.query(routesSql, (err, routes) => {
        if (err) {   return res.cc(err, 0);   }
        console.log("一级分类查询结果:", routes); // 调试输出
    db.query(routeSql, (err, routesData) => {
        if (err) {   return res.cc(err, 0);   }
        console.log("二级分类查询结果:", routesData); // 调试输出
         // 处理路由关联关系
         routes.forEach(route => {
         const children = routesData.filter(item => Number(item.route_id) === Number(route.id)); // 将 item.route_id 转换为数字
         console.log(`一级分类 ${route.name} 的二级分类:`, children); // 调试输出
         route.children = children;
            });
            // 返回最终构建的数据结构
            return res.cc(routes, 1);
        });
    });
});


// 查询路由分类列表
router.get('/Admin/Route_ClassList', (req, res) => {
    const data = req.query;
    let sql = `
        SELECT *
        FROM route_class`;
    // 查询所有路由信息
    db.query(sql, (err, routes) => {
        if (err) {
            return res.cc(err, 0);
        }
        return res.cc({ data: routes }, 1);
    });
});
// 查询路由列表
router.get('/Admin/Route_List', (req, res) => {
    const data = req.query;
    const limit = parseInt(data.limit) || 10; // 每页条数，默认为10
    const page = parseInt(data.page) || 1; // 当前页，默认为第1页
    const offset = (page - 1) * limit; // 计算偏移量

    let values = [];
    let conditions = []; //条件
    let sql = `SELECT r.*, c.name AS class_name
        FROM route r
        LEFT JOIN route_class c ON r.route_id = c.id`;
    // 遍历传递的参数，构建条件查询
    Object.keys(data).forEach(key => {
        // 过滤掉分页的参数，如 limit 和 page
        if (key !== 'limit' && key !== 'page' && key !== 'shop_id' && key !== 'startTime' && key !== 'endTime') {
            conditions.push(`h.${key} = ?`);
            values.push(data[key]);
        }
    });
    // 如果有查询条件，则加上 WHERE 子句
    if (conditions.length > 0) {
        sql += ` AND ` + conditions.join(' AND ');
    }

    // 添加分页查询
    sql += ` LIMIT ? OFFSET ?`;
    values.push(limit, offset);

    // 查询总记录数以便返回分页的总页数
    let countSql = `
            SELECT COUNT(*) AS total
            FROM route
        `;
    // 查询总页数 values.slice(0, -2)截取店铺凭证
    db.query(countSql, values.slice(0, -2), (countErr, countResult) => { // 切掉分页的 limit 和 offset 值
        if (countErr) {
            console.log(countErr);
            return res.send({ err: countErr });
        }
        let total = countResult[0].total; // 总记录数
        const totalPages = Math.ceil(total / limit); // 计算总页数
        //查询需要的数据
        db.query(sql, values, (err, result) => {
            if (err){
                res.cc(err,0);
            }
            res.cc({data:result,count:total},1)
        })
    });
})
// 构建路由树
function buildRouteTree111(routes) {
    const routeMap = {};
    const routeTree = [];

    // 把所有路由放入路由映射中
    routes.forEach(route => {
        // 初始化结构，确保 children 是空数组
        routeMap[route.id] = {
            id: route.id,
            name: route.name,
            path: route.path,
            is_show: route.is_show,
            route_id: route.route_id,
            class_name: route.class_name,
            children: []  // 确保此字段存在
        };
    });

    // 构建树形结构
    routes.forEach(route => {
        if (route.parent_id) {
            // 如果有 parent_id，将当前路由放入父路由的 children
            routeMap[route.parent_id].children.push(routeMap[route.id]);
        } else {
            // 否则添加到根节点
            routeTree.push(routeMap[route.id]);
        }
    });

    return routeTree;
}
// 添加路由
router.post('/Admin/addRoute_List', (req, res)=>{
    const data = req.body;
    // 计算利润
    const sql=`
        INSERT INTO route
        (path,name,is_show,route_id,icon) 
        VALUES(?,?,?,?,?);`
    // 解构赋值提交的参数
    let {path,name,is_show,route_id,icon} = data
    // 定义数据库数据
    let params = [
        path,name,is_show,route_id,icon
    ]
    // 执行
    db.query(sql, params, (err, result) => {
        if (err) {
            console.error(err);
            return res.cc({ err }); // 查询异常返回报错
        }
        const resdata = result;
        // 如果查询成功但没有结果，返回空结果
        if (resdata.length === 0) {
            return res.cc("添加失败");
        } else {
            // 如果没有 limit，直接返回所有查询结果
            res.cc({
            }, 1, "添加成功");
        }
    });
})
//删除路由列表
router.post('/Admin/deleteRouteClass_List', (req, res) => {
    // 获取请求体中的参数
    const { id } = req.body;
    const data = req.body;
    const sql=`DELETE FROM route where id=?`

    db.query(sql,id, (err, result) => {
        if (err) {
            console.error(err);
            return res.send({ err }); // 查询异常返回报错
        }
        // 检查是否有行被删除
        if (result.affectedRows === 0) {
            return res.cc("删除失败!");
        }
        // 返回成功信息
        res.cc("",1,"删除成功!",);
    });
});

//更改路由
router.post('/Admin/updateRoute_List', (req, res) => {
    // 获取请求体中的参数
    const { id,icon,path } = req.body; // 必须包含 id 和 shopUserId
    const updates = {};
    // 检查参数是否存在
    if (!id) {
        return res.cc("缺少必要的参数: id");
    }

    // 动态构建更新字段
    for (const key in req.body) {
        if (key !== 'id') { // 排除 id 和 shopUserId
            updates[key] = req.body[key];
        }
    }
    // 确保至少有一个字段需要更新
    if (Object.keys(updates).length === 0) {
        return res.cc("没有提供任何可更新的字段");
    }

    // 构建 SQL 更新语句
    const setClause = Object.keys(updates).map(key => `${key} = ?`).join(', ');
    const sql = `UPDATE route SET ${setClause} WHERE id = ?`;
    const updaIconSql = `UPDATE root_group SET name=?,is_show=?,icon=?,path=? WHERE class_id = ?`;

    // 执行更新操作
    const sqlValues = [...Object.values(updates), id];
    console.log('条件',sqlValues)
    //条件 过滤掉 is_show 和 id
    const sqlValues3 = [
        ...Object.entries(updates)
            .filter(([key]) => key !== 'is_show' && key !== 'id') // 过滤不需要的字段
            .map(([, value]) => value), // 获取剩余字段的值
        updates.id // 也可以直接通过 updates.id 获取 id
    ];
    db.query(sql, sqlValues, (err, result) => {
        if (err) {
            console.error(err);
            return res.cc(err.sqlMessage ); // 查询异常返回报错
        }
        // 检查是否有行被更改
        if (result.affectedRows === 0) {
            return res.cc("未找到对应的路由或未进行任何修改");
    }
        const data = req.body
        // 执行更新操作
        const sqlValues2 = [data.name,data.is_show,data.icon,data.path, data.id];
        console.log(2,updaIconSql,3,sqlValues2)
        console.log(555,req.body)
        // 同时去修改权限列表的该路由的值
        db.query(updaIconSql,sqlValues2, (err, result) => {
            if (err) {
                console.error(err);
                return res.cc(err.sqlMessage ); // 查询异常返回报错
            }
            // 检查是否有行被更改
            if (result.affectedRows === 0) {
                return res.cc("未找到对应的路由或未进行任何修改");
            }
            // 返回成功信息
            res.cc("",1,"路由修改成功, 重新登陆即可生效!",);
        });
    });
});

//添加权限组
router.post('/Admin/addAdminRoot', (req, res)=>{
    const data = req.body;
    // 计算利润
    // const sql=`
    //     INSERT INTO userroot
    //     (rootName,rootList)
    //     VALUES(?,?);`
    const sql=`
        INSERT INTO userroot
        (rootName)
        VALUES(?);`
    // // 解构赋值提交的参数
    // let {rootName,rootList} = data
    // // 定义数据库数据
    // let params = [
    //     rootName,rootList
    // ]
    // 解构赋值提交的参数
    let {rootName} = data
    // 定义数据库数据
    let params = [
        rootName
    ]
    // 执行
    db.query(sql, params, (err, result) => {
        if (err) {
            console.error(err);
            return res.cc({ err }); // 查询异常返回报错
        }
        const resdata = result;
        // 如果查询成功但没有结果，返回空结果
        if (resdata.length === 0) {
            return res.cc("添加失败");
        } else {
            // 如果没有 limit，直接返回所有查询结果
            res.cc({
            }, 1, "添加成功");
        }
    });
})
//查询权限组
router.get('/Admin/getAdminRoot_List', (req, res) => {
    const data = req.query;

    // 查询所有一级路由分类
    const rootSQL = `SELECT * FROM userroot`;
    // 查询所有二级路由 WHERE is_show = 1
    const rootGroup = `SELECT *,root_id as value,name as label FROM root_group`;

    db.query(rootSQL, (err, routes) => {
        if (err) {   return res.cc(err, 0);   }
        db.query(rootGroup, (err, routesData) => {
            if (err) {   return res.cc(err, 0);   }
            // console.log("二级分类查询结果:", routesData); // 调试输出
            // 处理路由关联关系
            routes.forEach(route => {
                const children = routesData.filter(item => Number(item.root_id) === Number(route.id)); // 将 item.route_id 转换为数字
                //console.log(`一级分类 ${route.name} 的二级分类:`, children);  调试输出
                route.children = children;
            });
            // 返回最终构建的数据结构
            return res.cc(routes, 1);
        });
    });
});
//修改权限组
router.post('/Admin/updateAdminRoot', (req, res) => {
    // 获取请求体中的参数
    const { id,path } = req.body; // 必须包含 id 和 shopUserId
    console.log('拿到的参数',req.body)
    const updates = {};
    // 检查参数是否存在
    if (!id) {
        return res.cc("缺少必要的参数: id");
    }
    // 动态构建更新字段
    for (const key in req.body) {
        if (key !== 'id' && key !== 'path') { // 排除 id 和 path
            updates[key] = req.body[key];
        }
    }
    // 确保至少有一个字段需要更新
    if (Object.keys(updates).length === 0) {
        return res.cc("没有提供任何可更新的字段");
    }
    console.log('参数',updates)
    // 构建 SQL 更新语句
    const setClause = Object.keys(updates).map(key => `${key} = ?`).join(', ');
    const sql = `UPDATE userroot SET ${setClause} WHERE id = ?`;

    // 执行更新操作
    const sqlValues = [...Object.values(updates), id];

    db.query(sql, sqlValues, (err, result) => {
        if (err) {
            console.error(err);
            return res.cc(err.sqlMessage ); // 查询异常返回报错
        }
        // 检查是否有行被更改
        if (result.affectedRows === 0) {
            return res.cc("未找到对应的路由或未进行任何修改");
        }
        // 删除已有数据 重新插入新的数据
        const sqlDel = `DELETE FROM root_group where root_id=?`;
        db.query(sqlDel,id, (err, result) => {
            if (err) {
                console.error('权限修改失败:', err);
                return res.cc('权限修改失败');
            }
            // 解析 path 数据并插入到 rootgroup 表中
            try {
                const pathData = JSON.parse(path); // 假设 path 是一个 JSON 字符串
                const insertValues = [];
                const placeholders = [];

                for (const item of pathData) {
                    console.log(1,item)
                    const { name, path: itemPath,route_id } = item; // 提取 id、name 和 path
                    // 拿到每一项的id 插入新表的时候作为class_id
                    const root_id = item.id
                    insertValues.push(id, name, itemPath,route_id,root_id); // 将每项的值放入数组
                    placeholders.push('(?, ?, ?, ?, ?)'); // 每组数据的占位符
                }
                console.log('这是item',pathData)
                const insertSql = `INSERT INTO root_group (root_id, name, path,route_id,class_id)
                VALUES ${placeholders.join(', ')}`;
                console.log('Sql',insertSql);
                db.query(insertSql, insertValues, (insertErr) => {
                    if (insertErr) {
                        console.error('路由权限录入失败:', insertErr);
                        return res.cc('路由权限录入失败');
                    }
                    // 返回成功信息
                    res.cc("", 1, "修改成功");
                });
                //res.cc("", 1, "修改成功");
            } catch (parseError)
            {
                console.error('解析 path 数据失败:', parseError);
                return res.cc("无效的路径数据");
            }
        })

    });
});
//删除权限组
router.post('/Admin/deleteAdminRoot', (req, res) => {
    // 获取请求体中的参数
    const { id } = req.body;
    const data = req.body;
    const sql=`DELETE FROM userroot where id=?`

    db.query(sql,id, (err, result) => {
        if (err) {
            console.error(err);
            return res.send({ err }); // 查询异常返回报错
        }
        // 检查是否有行被删除
        if (result.affectedRows === 0) {
            return res.cc("删除失败!");
        }

        const sql2=`DELETE FROM root_group where id=?`
        // 返回成功信息
        res.cc("",1,"删除成功!",);
    });
});

//查询用户权限组
router.get('/Admin/getUserRoot', (req, res) => {
    let data = req.query;
    // 查询权限
    const rootSQL = `SELECT * FROM userroot WHERE id = ?`;
    // 查询路由集
    const routeSQL = `SELECT *,root_id as value,name as label FROM root_group WHERE root_id = ?`;
    db.query(rootSQL,data.id,(err, result) => {
        if (err) {   return res.cc(err, 0);   }
        db.query(routeSQL,data.id,(err, resRoute) => {
            if (err) {   return res.cc(err, 0);   }
            result[0].children = resRoute
            // 返回最终构建的数据结构
            return res.cc(result, 1);
        });
    });
});

//查询用户可访问导航菜单
router.get('/Api/getAdminRoute_List', (req, res) => {

    const {username} = req.query
    //查询用户的权限
    const userRootSQL = `SELECT root FROM user where username=?`;
    db.query(userRootSQL,username ,(err, userRoot) => {
        if (err) {   return res.cc(err, 0);   }

    //存储该用户权限
    let data = userRoot[0];

    // 查询所有一级路由分类
    const rootSQL = `SELECT * FROM route_class`;
    db.query(rootSQL, (err, routes) => {
        if (err) {   return res.cc(err, 0);   }

        // 查询所有二级路由 WHERE is_show = 1
        const rootGroup = `SELECT *,root_id as value,name as label FROM root_group where root_id=?`;
        db.query(rootGroup,data.root, (err, routesData) => {
            const result = routes.map(route => {
                // 找到与当前route.id相匹配的routesData
                const children = routesData.filter(data => data.route_id === String(route.id));

                // 如果找到的children不为空，则将children添加到result中
                if (children.length > 0) {
                    return { ...route, children };
                }
                return route; // 如果没有children，返回原始route
            }).filter(route => route.children); // 只筛选出有children的route
            if (err) {   return res.cc(err, 0);   }
            // 返回最终构建的数据结构
            return res.cc(result, 1);
        });
    });
    })
});


module.exports = router;
